home *** CD-ROM | disk | FTP | other *** search
/ LiquidLibrary 2005 February / LiquidLibrary 2005 February - Disc 1.iso / pc / Portfolio Browser / Filters / PDF / LIB / gs_res.ps < prev    next >
Text File  |  2003-01-03  |  29KB  |  918 lines
  1. %    Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is licensed to a single customer by Artifex Software Inc.
  4. % under the terms of a specific OEM agreement.
  5.  
  6. % $RCSfile$ $Revision$
  7. % Initialization file for Level 2 resource machinery.
  8. % When this is run, systemdict is still writable,
  9. % but (almost) everything defined here goes into level2dict.
  10.  
  11. level2dict begin
  12.  
  13. (BEGIN RESOURCES) VMDEBUG
  14.  
  15. % We keep track of (global) instances with another entry in the resource
  16. % dictionary, an .Instances dictionary.  For categories with implicit
  17. % instances, the values in .Instances are the same as the keys;
  18. % for other categories, the values are [instance status size].
  19.  
  20. % Note that the dictionary that defines a resource category is stored
  21. % in global VM.  The PostScript manual says that each category must
  22. % manage global and local instances separately.  However, objects in
  23. % global VM other than systemdict can't reference objects in local VM.
  24. % This means that the resource category dictionary, which would otherwise be
  25. % the obvious place to keep track of the instances, can't be used to keep
  26. % track of local instances.  Instead, we define a dictionary in local VM
  27. % called localinstancedict, in which the key is the category name and
  28. % the value is the analogue of .Instances for local instances.
  29.  
  30. % We don't currently implement automatic resource unloading.
  31. % When and if we do, it should be hooked to the garbage collector.
  32. % However, Ed Taft of Adobe says their interpreters don't implement this
  33. % either, so we aren't going to worry about it for a while.
  34.  
  35. currentglobal false setglobal systemdict begin
  36.   /localinstancedict 5 dict
  37.   .forcedef    % localinstancedict is local, systemdict is global
  38. end true setglobal
  39. /.emptydict 0 dict readonly def
  40. setglobal
  41.  
  42. % Resource category dictionaries have the following keys (those marked with
  43. % * are optional):
  44. %    Standard, defined in the Red Book:
  45. %        Category (name)
  46. %        *InstanceType (name)
  47. %        DefineResource
  48. %            <key> <instance> DefineResource <instance>
  49. %        UndefineResource
  50. %            <key> UndefineResource -
  51. %        FindResource
  52. %            <key> FindResource <instance>
  53. %        ResourceStatus
  54. %            <key> ResourceStatus <status> <size> true
  55. %            <key> ResourceStatus false
  56. %        ResourceForAll
  57. %            <template> <proc> <scratch> ResourceForAll -
  58. %        *ResourceFileName
  59. %            <key> <scratch> ResourceFileName <filename>
  60. %    Additional, specific to our implementation:
  61. %        .Instances (dictionary)
  62. %        .LocalInstances
  63. %            - .LocalInstances <dict>
  64. %        .GetInstance
  65. %            <key> .GetInstance <instance> -true-
  66. %            <key> .GetInstance -false-
  67. %        .CheckResource
  68. %            <key> <value> .CheckResource <key> <value> <ok>
  69. %              (or may give an error if not OK)
  70. %        .DoLoadResource
  71. %            <key> .DoLoadResource <key> (may give an error)
  72. %        .LoadResource
  73. %            <key> .LoadResource - (may give an error)
  74. %        .ResourceFile
  75. %            <key> .ResourceFile <file> -true-
  76. %            <key> .ResourceFile <key> -false-
  77. %        .ResourceFileStatus
  78. %            <key> .ResourceFileStatus 2 <vmusage> -true-
  79. %            <key> .ResourceFileStatus -false-
  80. % All the above procedures expect that the top dictionary on the d-stack
  81. % is the resource dictionary.
  82.  
  83. % Define enough of the Category category so we can define other categories.
  84. % The dictionary we're about to create will become the Category
  85. % category definition dictionary.
  86.  
  87. % .findcategory and .resourceexec are only called from within the
  88. % implementation of the resource 'operators', so they doesn't have to worry
  89. % about cleaning up the stack if they fail (the interpreter's stack
  90. % protection machinery for pseudo-operators takes care of this).
  91. /.findcategory {    % <name> .findcategory -
  92.             %   (pushes the category on the dstack)
  93.   /Category findresource begin
  94. } bind def
  95.  
  96. /.resourceexec {    % <key> /xxxResource .resourceexec -
  97.             %   (also pops the category from the dstack)
  98.   load exec end
  99. } bind def
  100.  
  101. % .getvminstance treats instances on disk as undefined.
  102. /.getvminstance {    % <key> .getvminstance <instance> -true-
  103.             % <key> .getvminstance -false-
  104.   .GetInstance {
  105.     dup 1 get 2 ne { true } { pop false } ifelse
  106.   } {
  107.     false
  108.   } ifelse
  109. } bind def
  110.  
  111. 20 dict begin
  112.  
  113.         % Standard entries
  114.  
  115. /Category /Category def
  116. /InstanceType /dicttype def
  117.  
  118. /DefineResource {
  119.     .CheckResource {
  120.       dup /Category 3 index cvlit .growput
  121.       dup [ exch 0 -1 ] exch
  122.       .Instances 4 2 roll put
  123.         % Make the Category dictionary read-only.  We will have to
  124.         % use .forceput / .forcedef later to replace the dummy,
  125.         % empty .Instances dictionary with the real one later.
  126.       readonly
  127.     } {
  128.       /defineresource load /typecheck signalerror
  129.     } ifelse
  130. } bind def
  131. /FindResource        % (redefined below)
  132.     { .Instances exch get 0 get
  133.     } bind def
  134.  
  135.         % Additional entries
  136.  
  137. /.Instances 30 dict def
  138. .Instances /Category [currentdict 0 -1] put
  139.  
  140. /.LocalInstances 0 dict def
  141. /.GetInstance
  142.     { .Instances exch .knownget
  143.     } bind def
  144. /.CheckResource
  145.     { dup gcheck currentglobal and
  146.        { /DefineResource /FindResource /ResourceForAll /ResourceStatus
  147.          /UndefineResource }
  148.        { 2 index exch known and }
  149.       forall
  150.       not { /defineresource load /invalidaccess signalerror } if
  151.       true
  152.     } bind def
  153.  
  154. .Instances end begin    % for the base case of findresource
  155.  
  156. (END CATEGORY) VMDEBUG
  157.  
  158. % Define the resource operators.  We use the "stack protection" feature of
  159. % odef to make sure the stacks are restored properly on an error.
  160. % This requires that the operators not pop anything from the stack until
  161. % they have executed their logic successfully.  We can't make this
  162. % work for resourceforall, because the procedure it executes mustn't see
  163. % the operands of resourceforall on the stack, but we can make it work for
  164. % the others.
  165.  
  166. % findresource is the only operator that needs to bind //Category.
  167. /findresource {        % <key> <category> findresource <instance>
  168.     2 copy dup /Category eq
  169.       { pop //Category 0 get begin } { .findcategory } ifelse
  170.     /FindResource .resourceexec exch pop exch pop
  171. } bind
  172. end        % .Instances of Category
  173. odef
  174.  
  175. /defineresource {    % <key> <instance> <category> defineresource <instance>
  176.     3 copy .findcategory
  177.     currentdict /InstanceType known {
  178.       dup type InstanceType ne {
  179.         dup type /packedarraytype eq InstanceType /arraytype eq and
  180.         not { /defineresource load /typecheck signalerror } if
  181.       } if
  182.     } if
  183.     /DefineResource .resourceexec
  184.     4 1 roll pop pop pop
  185. } bind odef
  186. % We must prevent resourceforall from automatically restoring the stacks,
  187. % because we don't want the stacks restored if proc causes an error.
  188. % On the other hand, resourceforall is defined in the PLRM as an operator,
  189. % so it must have type /operatortype.  We hack this by taking advantage of
  190. % the fact that the interpreter optimizes tail calls, so stack protection
  191. % doesn't apply to the very last token of an operator procedure.
  192. /resourceforall1 {    % <template> <proc> <scratch> <category> resourceforall1 -
  193.     dup /Category findresource begin
  194.     /ResourceForAll load
  195.         % Make sure we can recover the original operands.
  196.         % We must create the array in local VM, in case any of the
  197.         % operands are local.
  198.         % Stack: ...operands... proc
  199.     5 copy pop .currentglobal false .setglobal 5 1 roll
  200.     4 packedarray exch .setglobal count
  201.         % Stack: ...operands... proc saved count
  202.     4 -1 roll pop        % pop the category
  203.     /stopped load 3 1 roll
  204.     3 .execn
  205.         % Stack: ... stopped saved count
  206.     3 -1 roll {
  207.       .currentstackprotect {
  208.         % The count is the original stack depth + 2.
  209.         count exch 4 sub sub { exch pop } repeat
  210.         aload pop end
  211.       } {
  212.         % Don't restore the stacks.
  213.         pop pop
  214.       } ifelse stop
  215.     } {
  216.       pop pop end
  217.     } ifelse
  218. } bind def
  219. /resourceforall {    % <template> <proc> <scratch> <category> resourceforall1 -
  220.     //resourceforall1 exec        % see above
  221. } bind odef
  222. /resourcestatus {    % <key> <category> resourcestatus <status> <size> true
  223.             % <key> <category> resourcestatus false
  224.     2 copy .findcategory /ResourceStatus .resourceexec
  225.      { 4 2 roll pop pop true } { pop pop false } ifelse
  226. } bind odef
  227. /undefineresource {    % <key> <category> undefineresource -
  228.     2 copy .findcategory /UndefineResource .resourceexec pop pop
  229. } bind odef
  230.  
  231. % Define the system parameters used for the Generic implementation of
  232. % ResourceFileName.
  233. systemdict begin
  234. currentdict /pssystemparams known not {
  235.   /pssystemparams 10 dict readonly def
  236. } if
  237. pssystemparams begin
  238.   /FontResourceDir (/Resource/Font/) readonly .forcedef    % pssys'params is r-o
  239.   /GenericResourceDir (/Resource/) readonly .forcedef    % pssys'params is r-o
  240.   /GenericResourcePathSep (/) readonly .forcedef    % pssys'params is r-o
  241. end
  242. end
  243.  
  244. % Define the generic algorithm for computing resource file names.
  245. /.rfnstring 100 string def
  246. /.genericrfn        % <key> <scratch> <prefix> .genericrfn <filename>
  247.  { 3 -1 roll //.rfnstring cvs concatstrings exch copy
  248.  } bind def
  249.  
  250. % Define a procedure for making a packed array in local VM.
  251. /.localpackedarray {    % <obj1> ... <objn> <n> .localpackedarray <packedarray>
  252.   .currentglobal false .setglobal 1 index 2 add 1 roll
  253.   packedarray exch .setglobal
  254. } bind def
  255.  
  256. % Define the Generic category.
  257.  
  258. /Generic mark
  259.  
  260.         % Standard entries
  261.  
  262. % We're still running in Level 1 mode, so dictionaries won't expand.
  263. % Leave room for the /Category entry.
  264. /Category null
  265.  
  266. % Implement the body of Generic resourceforall for local, global, and
  267. % external cases.  'args' is [template proc scratch resdict].
  268. /.enumerateresource {    % <key> [- <proc> <scratch>] .enumerateresource -
  269.   1 index type dup /stringtype eq exch /nametype eq or {
  270.     exch 1 index 2 get cvs exch
  271.   } if
  272.     % Use .setstackprotect to prevent the stacks from being restored if
  273.     % an error occurs during execution of proc.
  274.   1 get false .setstackprotect exec true .setstackprotect
  275. } bind def
  276. /.localresourceforall {        % <key> <value> <args> .localr'forall -
  277.   exch pop
  278.   2 copy 0 get .stringmatch { .enumerateresource } { pop pop } ifelse
  279. } bind def
  280. /.globalresourceforall {    % <key> <value> <args> .globalr'forall -
  281.   exch pop
  282.   2 copy 0 get .stringmatch {
  283.     dup 3 get begin .LocalInstances end 2 index known not {
  284.       .enumerateresource
  285.     } if
  286.   } {
  287.     pop pop
  288.   } ifelse
  289. } bind def
  290. /.externalresourceforall {    % <filename> <len> <args> .externalr'forall -
  291.   3 1 roll 1 index length 1 index sub getinterval exch
  292.   dup 3 get begin .Instances .LocalInstances end
  293.         % Stack: key args insts localinsts
  294.   3 index known {
  295.     pop pop pop
  296.   } {
  297.     2 index known { pop pop } { .enumerateresource } ifelse
  298.   } ifelse
  299. } bind def
  300.  
  301. /DefineResource {
  302.     .CheckResource
  303.        { dup [ exch 0 -1 ]
  304.             % Stack: key value instance
  305.          currentglobal
  306.           { false setglobal 2 index UndefineResource    % remove local def if any
  307.         true setglobal
  308.         .Instances dup //.emptydict eq {
  309.           pop 3 dict
  310.             % As noted above, Category dictionaries are read-only,
  311.             % so we have to use .forcedef here.
  312.           /.Instances 1 index .forcedef    % Category dict is read-only
  313.         } if
  314.           }
  315.           { .LocalInstances dup //.emptydict eq
  316.              { pop 3 dict localinstancedict Category 2 index put
  317.          }
  318.         if
  319.           }
  320.          ifelse
  321.             % Stack: key value instance instancedict
  322.          3 index 2 index .growput
  323.             % Now make the resource value read-only.
  324.          0 2 copy get { readonly } .internalstopped pop
  325.          dup 4 1 roll put exch pop exch pop
  326.        }
  327.        { /defineresource load /typecheck signalerror
  328.        }
  329.     ifelse
  330. } bind executeonly        % executeonly to prevent access to .forcedef
  331. /UndefineResource
  332.     {  { dup 2 index .knownget
  333.           { dup 1 get 1 ge
  334.          { dup 0 null put 1 2 put pop pop }
  335.          { pop exch .undef }
  336.         ifelse
  337.           }
  338.           { pop pop
  339.           }
  340.          ifelse
  341.        }
  342.       currentglobal
  343.        { 2 copy .Instances exch exec
  344.        }
  345.       if .LocalInstances exch exec
  346.     } bind
  347. % Because of some badly designed code in Adobe's CID font downloader that
  348. % makes findresource and resourcestatus deliberately inconsistent with each
  349. % other, the default FindResource must not call ResourceStatus if there is
  350. % an instance of the desired name already defined in VM.
  351. /FindResource {
  352.     dup .getvminstance {
  353.       exch pop 0 get
  354.     } {
  355.       dup ResourceStatus {
  356.         pop 1 gt {
  357.           .DoLoadResource .getvminstance not {
  358.         /findresource load /undefinedresource signalerror
  359.           } if 0 get
  360.         } {
  361.           .GetInstance pop 0 get
  362.         } ifelse
  363.       } {
  364.        /findresource load /undefinedresource signalerror
  365.       } ifelse
  366.     } ifelse
  367. } bind
  368. % Because of some badly designed code in Adobe's CID font downloader, the
  369. % definition of ResourceStatus for Generic and Font must be the same (!).
  370. % We patch around this by using an intermediate .ResourceFileStatus procedure.
  371. /ResourceStatus {
  372.     dup .GetInstance {
  373.       exch pop dup 1 get exch 2 get true
  374.     } {
  375.       .ResourceFileStatus
  376.     } ifelse
  377. } bind
  378. /.ResourceFileStatus {
  379.     .ResourceFile { closefile 2 -1 true } { pop false } ifelse
  380. } bind
  381. /ResourceForAll {
  382.         % **************** Doesn't present instance groups in
  383.         % **************** the correct order yet.
  384.         % Construct a new procedure to hold the arguments.
  385.         % All objects constructed here must be in local VM to avoid
  386.         % a possible invalidaccess.
  387.     currentdict 4 .localpackedarray    % [template proc scratch resdict]
  388.         % We must pop the resource dictionary off the dict stack
  389.         % when doing the actual iteration, and restore it afterwards.
  390.     .currentglobal not {
  391.       .LocalInstances length 0 ne {
  392.         % We must do local instances, and do them first.
  393.         //.localresourceforall {exec} 0 get 3 .localpackedarray cvx
  394.         .LocalInstances exch {forall} 0 get 1 index 0 get
  395.         currentdict end 3 .execn begin
  396.       } if
  397.     } if
  398.         % Do global instances next.
  399.     //.globalresourceforall {exec} 0 get 3 .localpackedarray cvx
  400.     .Instances exch cvx {forall} 0 get 1 index 0 get
  401.     currentdict end 3 .execn begin
  402.     currentdict /ResourceFileName known {
  403.         % Finally, do instances stored on files.
  404.       dup 0 get 100 string ResourceFileName
  405.       dup length 2 index 0 get length sub 3 -1 roll
  406.       //.externalresourceforall {exec} 0 get 4 .localpackedarray cvx
  407.       100 string {filenameforall} 0 get
  408.       currentdict end 2 .execn begin null    % for pop
  409.     } if pop
  410. } bind
  411. /ResourceFileName
  412.     { /GenericResourceDir getsystemparam 
  413.       Category .namestring concatstrings
  414.       /GenericResourcePathSep getsystemparam concatstrings
  415.       .genericrfn
  416.     } bind
  417.  
  418.         % Additional entries
  419.  
  420. % Unfortunately, we can't create the real .Instances dictionary now,
  421. % because if someone copies the Generic category (which pp. 95-96 of the
  422. % 2nd Edition Red Book says is legitimate), they'll wind up sharing
  423. % the .Instances.  Instead, we have to create .Instances on demand,
  424. % just like the entry in localinstancedict.
  425. % We also have to prevent anyone from creating instances of Generic itself.
  426. /.Instances //.emptydict
  427.  
  428. /.LocalInstances
  429.     { localinstancedict Category .knownget not { //.emptydict } if
  430.     } bind
  431. /.GetInstance
  432.     { currentglobal
  433.        { .Instances exch .knownget }
  434.        { .LocalInstances 1 index .knownget
  435.           { exch pop true }
  436.           { .Instances exch .knownget }
  437.          ifelse
  438.        }
  439.       ifelse
  440.     } bind
  441. /.CheckResource
  442.     { true
  443.     } bind
  444. /.vmused {
  445.         % - .vmused <usedvalue>
  446.         % usedvalue = vmstatus in global + vmstatus in local.
  447.   0 2 {
  448.     .currentglobal not .setglobal
  449.     vmstatus pop exch pop add
  450.   } repeat
  451. } bind def
  452. /.DoLoadResource {
  453.         % .LoadResource may push entries on the operand stack.
  454.         % It is an undocumented feature of Adobe implementations,
  455.         % which we must match for the sake of some badly written
  456.         % font downloading code, that such entries are popped
  457.         % automatically.
  458.     count 1 index cvlit .vmused
  459.         % Stack: key count litkey memused
  460.     {.LoadResource} 4 1 roll 4 .execn
  461.         % Stack: ... count key memused
  462.     .vmused exch sub
  463.     1 index .getvminstance not {
  464.       pop dup /undefinedresource signalerror    % didn't load
  465.     } if
  466.     dup 1 1 put
  467.     2 3 -1 roll put
  468.         % Stack: ... count key
  469.     exch count 1 sub exch sub {exch pop} repeat
  470. } bind
  471. /.LoadResource
  472.     { dup .ResourceFile
  473.        { exch pop currentglobal
  474.           { .runresource }
  475.           { true setglobal { .runresource } stopped false setglobal { stop } if }
  476.          ifelse
  477.        }
  478.        { dup /undefinedresource signalerror
  479.        }
  480.      ifelse
  481.     } bind
  482. /.ResourceFile
  483.     { currentdict /ResourceFileName known
  484.        { mark 1 index 100 string { ResourceFileName }
  485.          .internalstopped
  486.           { cleartomark false }
  487.           { exch pop findlibfile
  488.          { exch pop exch pop true }
  489.          { pop false }
  490.         ifelse
  491.           }
  492.          ifelse
  493.        }
  494.        { false }
  495.       ifelse
  496.     } bind
  497.  
  498. .dicttomark
  499. /Category defineresource pop
  500.  
  501. % Fill in the rest of the Category category.
  502. /Category /Category findresource dup
  503. /Generic /Category findresource begin {
  504.   /FindResource /ResourceForAll /ResourceStatus /.ResourceFileStatus
  505.   /UndefineResource /ResourceFileName
  506.   /.ResourceFile /.LoadResource /.DoLoadResource
  507. } { dup load put dup } forall
  508. pop readonly pop end
  509.  
  510. (END GENERIC) VMDEBUG
  511.  
  512. % Define the fixed categories.
  513.  
  514. mark
  515.     % Non-Type categories with existing entries.
  516.  /ColorSpaceFamily
  517.    { }    % These must be deferred, because optional features may add some.
  518.  /Emulator
  519.    mark EMULATORS { cvn } forall .packtomark
  520.  /Filter
  521.    { }    % These must be deferred, because optional features may add some.
  522.  /IODevice
  523.     % Loop until the .getiodevice gets a rangecheck.
  524.    errordict /rangecheck 2 copy get
  525.    errordict /rangecheck { pop stop } put    % pop the command
  526.    mark 0 { {
  527.     dup .getiodevice dup null eq { pop } { exch } ifelse 1 add
  528.    } loop} .internalstopped
  529.    pop pop pop .packtomark
  530.    4 1 roll put
  531.    .clearerror
  532.     % Type categories listed in the Red Book.
  533.  /ColorRenderingType
  534.    { }    % These must be deferred, because optional features may add some.
  535.  /FMapType
  536.    { }    % These must be deferred, because optional features may add some.
  537.  /FontType
  538.    { }    % These must be deferred, because optional features may add some.
  539.  /FormType
  540.    { }    % These must be deferred, because optional features may add some.
  541.  /HalftoneType
  542.    { }    % These must be deferred, because optional features may add some.
  543.  /ImageType
  544.    { }    % Deferred, optional features may add some.
  545.  /PatternType
  546.    { }  % Deferred, optional features may add some.
  547.     % Type categories added since the Red Book.
  548.  /setsmoothness where {
  549.    pop /ShadingType { }    % Deferred, optional features may add some.
  550.  } if
  551. counttomark 2 idiv
  552.  { mark
  553.  
  554.         % Standard entries
  555.  
  556.         % We'd like to prohibit defineresource,
  557.         % but because optional features may add entries, we can't.
  558.         % We can at least require that the key and value match.
  559.    /DefineResource
  560.     { currentglobal not
  561.        { /defineresource load /invalidaccess signalerror }
  562.        { 2 copy ne
  563.           { /defineresource load /rangecheck signalerror }
  564.           { dup .Instances 4 -2 roll .growput }
  565.          ifelse
  566.        }
  567.       ifelse
  568.     } bind
  569.    /UndefineResource
  570.     { /undefineresource load /invalidaccess signalerror } bind
  571.    /FindResource
  572.     { .Instances 1 index .knownget
  573.        { exch pop }
  574.        { /findresource load /undefinedresource signalerror }
  575.       ifelse
  576.     } bind
  577.    /ResourceStatus
  578.     { .Instances exch known { 0 0 true } { false } ifelse } bind
  579.    /ResourceForAll
  580.     /Generic /Category findresource /ResourceForAll get
  581.  
  582.         % Additional entries
  583.  
  584.    counttomark 2 add -1 roll
  585.    dup length dict dup begin exch { dup def } forall end
  586.         % We'd like to make the .Instances readonly here,
  587.         % but because optional features may add entries, we can't.
  588.    /.Instances exch
  589.    /.LocalInstances    % used by ResourceForAll
  590.     0 dict def
  591.  
  592.    .dicttomark /Category defineresource pop
  593.  } repeat pop
  594.  
  595. (END FIXED) VMDEBUG
  596.  
  597. % Define the other built-in categories.
  598.  
  599. /.definecategory    % <name> -mark- <key1> ... <valuen> .definecategory -
  600.  { counttomark 2 idiv 2 add        % .Instances, Category
  601.    /Generic /Category findresource dup maxlength 3 -1 roll add
  602.    dict .copydict begin
  603.    counttomark 2 idiv { def } repeat pop    % pop the mark
  604.    currentdict end /Category defineresource pop
  605.  } bind def
  606.  
  607. /ColorRendering mark /InstanceType /dicttype .definecategory
  608. % ColorSpace is defined below
  609. % Encoding is defined below
  610. % Font is defined below
  611. /Form mark /InstanceType /dicttype .definecategory
  612. /Halftone mark /InstanceType /dicttype .definecategory
  613. /Pattern mark /InstanceType /dicttype .definecategory
  614. /ProcSet mark /InstanceType /dicttype .definecategory
  615. % Added since the Red Book:
  616. /ControlLanguage mark /InstanceType /dicttype .definecategory
  617. /HWOptions mark /InstanceType /dicttype .definecategory
  618. /Localization mark /InstanceType /dicttype .definecategory
  619. /OutputDevice mark /InstanceType /dicttype .definecategory
  620. /PDL mark /InstanceType /dicttype .definecategory
  621. % CIDFont, CIDMap, and CMap are defined in gs_cidfn.ps
  622. % FontSet is defined in gs_cff.ps
  623. % IdiomSet is defined in gs_ll3.ps
  624. % InkParams and TrapParams are defined in gs_trap.ps
  625.  
  626. (END MISC) VMDEBUG
  627.  
  628. % Define the ColorSpace category.
  629.  
  630. /.defaultcsnames mark
  631.   /DefaultGray 0
  632.   /DefaultRGB 1
  633.   /DefaultCMYK 2
  634. .dicttomark readonly def
  635.  
  636. % The "hooks" are no-ops here, redefined in LL3.
  637. /.definedefaultcs {    % <index> <value> .definedefaultcs -
  638.   pop pop
  639. } bind def
  640. /.undefinedefaultcs {    % <index> .undefinedefaultcs -
  641.   pop
  642. } bind def
  643.  
  644. /ColorSpace mark
  645.  
  646. /InstanceType /arraytype
  647.  
  648. % We keep track of whether there are any local definitions for any of
  649. % the Default keys.  This information must get saved and restored in
  650. % parallel with the local instance dictionary, so it must be stored in
  651. % local VM.
  652. userdict /.localcsdefaults false put
  653.  
  654. /DefineResource {
  655.   2 copy /Generic /Category findresource /DefineResource get exec
  656.   exch pop
  657.   exch //.defaultcsnames exch .knownget {
  658.     1 index .definedefaultcs
  659.     currentglobal not { .userdict /.localcsdefaults true put } if
  660.   } if
  661. } bind
  662.  
  663. /UndefineResource {
  664.   dup /Generic /Category findresource /UndefineResource get exec
  665.   //.defaultcsnames 1 index .knownget {
  666.     % Stack: resname index
  667.     currentglobal {
  668.       .undefinedefaultcs pop
  669.     } {
  670.     % We removed the local definition, but there might be a global one.
  671.       exch .GetInstance {
  672.     0 get .definedefaultcs
  673.       } {
  674.     .undefinedefaultcs
  675.       } ifelse
  676.     % Recompute .localcsdefaults by scanning.  This is rarely needed.
  677.       .userdict /.localcsdefaults false //.defaultcsnames {
  678.     pop .LocalInstances exch known { pop true exit } if
  679.       } forall put
  680.     } ifelse
  681.   } {
  682.     pop
  683.   } ifelse
  684. } bind
  685.  
  686. .definecategory            % ColorSpace
  687.  
  688. % Define the Encoding category.
  689.  
  690. /Encoding mark
  691.  
  692. /InstanceType /arraytype
  693.  
  694. % Handle already-registered encodings, including lazily loaded encodings
  695. % that aren't loaded yet.
  696.  
  697. /.Instances mark
  698.   EncodingDirectory
  699.    { dup length 256 eq { [ exch readonly 0 -1 ] } { pop [null 2 -1] } ifelse
  700.    } forall
  701. .dicttomark
  702.  
  703. /.ResourceFileDict mark
  704.   EncodingDirectory
  705.    { dup length 256 eq { pop pop } { 0 get } ifelse
  706.    } forall
  707. .dicttomark
  708.  
  709. /ResourceFileName
  710.  { .ResourceFileDict 2 index .knownget
  711.     { exch copy exch pop }
  712.     { /Generic /Category findresource /ResourceFileName get exec }
  713.    ifelse
  714.  } bind
  715.  
  716. .definecategory            % Encoding
  717.  
  718. % Make placeholders in level2dict for the redefined Encoding operators,
  719. % so that they will be swapped properly when we switch language levels.
  720.  
  721. /.findencoding /.findencoding load def
  722. /findencoding /findencoding load def
  723. /.defineencoding /.defineencoding load def
  724.  
  725. (END ENCODING) VMDEBUG
  726.  
  727. % Define the Font category.
  728.  
  729. /.fontstatus {        % <fontname> .fontstatus <fontname> <found>
  730.   {        % Create a loop context just so we can exit it early.
  731.         % Check Fontmap.
  732.     Fontmap 1 index .knownget {
  733.       {
  734.     dup type /nametype eq {
  735.       .fontstatus { pop null exit } if
  736.     } {
  737.       dup type /stringtype eq {
  738.         findlibfile { closefile pop null exit } if pop
  739.       } {
  740.         % Procedure, assume success.
  741.         pop null exit
  742.       } ifelse
  743.     } ifelse
  744.       } forall dup null eq { pop true exit } if
  745.     } if
  746.         % Convert names to strings; give up on other types.
  747.     dup type /nametype eq { .namestring } if
  748.     dup type /stringtype ne { false exit } if
  749.         % Check the resource directory.
  750.     dup .fonttempstring /FontResourceDir getsystemparam .genericrfn
  751.     status {
  752.       pop pop pop pop true exit
  753.     } if
  754.         % Check for a file on the search path with the same name
  755.         % as the font.
  756.     findlibfile { closefile true exit } if
  757.         % Scan a FONTPATH directory and try again.
  758.     .scannextfontdir not { false exit } if
  759.   } loop
  760. } bind def
  761.  
  762. /Font mark
  763.  
  764. /InstanceType /dicttype
  765.  
  766. /DefineResource
  767.     { 2 copy //definefont exch pop
  768.       /Generic /Category findresource /DefineResource get exec
  769.     } bind
  770. /UndefineResource
  771.     { dup //undefinefont
  772.       /Generic /Category findresource /UndefineResource get exec
  773.     } bind
  774. /FindResource {
  775.     dup .getvminstance {
  776.       exch pop 0 get
  777.     } {
  778.       dup ResourceStatus {
  779.         pop 1 gt { .loadfontresource } { .GetInstance pop 0 get } ifelse
  780.       } {
  781.         .loadfontresource
  782.       } ifelse
  783.     } ifelse
  784. } bind
  785. /ResourceForAll {
  786.     { .scannextfontdir not { exit } if } loop
  787.     /Generic /Category findresource /ResourceForAll get exec
  788. } bind
  789. /.ResourceFileStatus {
  790.     .fontstatus { pop 2 -1 true } { pop false } ifelse
  791. } bind
  792.  
  793. /.loadfontresource {
  794.     dup vmstatus pop exch pop exch
  795.         % Hack: rebind .currentresourcefile so that all calls of
  796.         % definefont will know these are built-in fonts.
  797.     currentfile {pop //findfont exec} .execasresource  % (findfont is a procedure)
  798.     exch vmstatus pop exch pop exch sub
  799.         % stack: name font vmused
  800.         % findfont has the prerogative of not calling definefont
  801.         % in certain obscure cases of font substitution.
  802.     2 index .getvminstance {
  803.       dup 1 1 put
  804.       2 3 -1 roll put
  805.     } {
  806.       pop
  807.     } ifelse exch pop
  808. } bind
  809.  
  810. /.Instances FontDirectory length 2 mul dict
  811.  
  812. .definecategory            % Font
  813.  
  814. % Redefine font "operators".
  815. /.definefontmap
  816.  { /Font /Category findresource /.Instances get
  817.    dup 3 index known
  818.     { pop
  819.     }
  820.     { 2 index
  821.         % Make sure we create the array in global VM.
  822.       .currentglobal true .setglobal
  823.       [null 2 -1] exch .setglobal
  824.       .growput
  825.     }
  826.    ifelse
  827.    //.definefontmap exec
  828.  } bind def
  829.  
  830. % Make sure the old definitions are still in systemdict so that
  831. % they will get bound properly.
  832. systemdict begin
  833.   /.origdefinefont /definefont load def
  834.   /.origundefinefont /undefinefont load def
  835.   /.origfindfont /findfont load def
  836. end
  837. /definefont {
  838.   /Font defineresource
  839. } bind odef
  840. /undefinefont {
  841.   /Font undefineresource
  842. } bind odef
  843. % The Red Book requires that findfont be a procedure, not an operator,
  844. % but it still needs to restore the stacks reliably if it fails.
  845. /.findfontop {
  846.   /Font findresource
  847. } bind odef
  848. /findfont {
  849.   .findfontop
  850. } bind def    % Must be a procedure, not an operator
  851.  
  852. % Remove initialization utilities.
  853. currentdict /.definecategory .undef
  854. currentdict /.emptydict .undef
  855.  
  856. end                % level2dict
  857.  
  858. % Convert deferred resources after we finally switch to Level 2.
  859.  
  860. /.fixresources {
  861.     % Encoding resources
  862.   EncodingDirectory
  863.    { dup length 256 eq
  864.       { /Encoding defineresource pop }
  865.       { pop pop }
  866.      ifelse
  867.    } forall
  868.   /.findencoding { /Encoding findresource } bind def
  869.   /findencoding /.findencoding load def        % must be a procedure
  870.   /.defineencoding { /Encoding defineresource pop } bind def
  871.     % ColorRendering resources and ProcSet
  872.   systemdict /ColorRendering .knownget {
  873.     /ColorRendering exch /ProcSet defineresource pop
  874.     systemdict /ColorRendering undef
  875.     /Default currentcolorrendering /ColorRendering defineresource pop
  876.   } if
  877.     % ColorSpace resources
  878.   systemdict /CIEsRGB .knownget {
  879.     /sRGB exch /ColorSpace defineresource pop
  880.     systemdict /CIEsRGB undef
  881.   } if
  882.     % ColorSpaceFamily resources
  883.   colorspacedict { pop dup /ColorSpaceFamily defineresource pop } forall
  884.     % Filter resources
  885.   filterdict { pop dup /Filter defineresource pop } forall
  886.     % FontType and FMapType resources
  887.   buildfontdict { pop dup /FontType defineresource pop } forall
  888.   mark
  889.     buildfontdict 0 known { 2 3 4 5 6 7 8 } if
  890.     buildfontdict 9 known { 9 } if
  891.   counttomark { dup /FMapType defineresource pop } repeat pop
  892.     % FormType resources
  893.   .formtypes { pop dup /FormType defineresource pop } forall
  894.     % HalftoneType resources
  895.   .halftonetypes { pop dup /HalftoneType defineresource pop } forall
  896.     % ColorRenderingType resources
  897.   .colorrenderingtypes {pop dup /ColorRenderingType defineresource pop} forall
  898.     % ImageType resources
  899.   .imagetypes { pop dup /ImageType defineresource pop } forall
  900.     % PatternType resources
  901.   .patterntypes { pop dup /PatternType defineresource pop } forall
  902.     % Make the fixed resource categories immutable.
  903.   /.shadingtypes where {
  904.     pop .shadingtypes { pop dup /ShadingType defineresource pop } forall
  905.   } if
  906.   [ /ColorSpaceFamily /Emulator /Filter /IODevice /ColorRenderingType
  907.     /FMapType /FontType /FormType /HalftoneType /ImageType /PatternType
  908.     /.shadingtypes where { pop /ShadingType } if
  909.   ] {
  910.     /Category findresource
  911.     dup /.Instances get readonly pop
  912.     .LocalInstances readonly pop
  913.     readonly pop
  914.   } forall
  915.     % clean up
  916.   systemdict /.fixresources undef
  917. } bind def
  918.